package functional.higherorderfunction;

/**
 * @ClassName TransformFunction
 * @PackageName functional.higherOrderFunction
 * @projectName myThread
 * @Description 
 * @Author games
 * @Date 2025/8/26 下午2:33
 * @Version 1.0
 */

import java.util.function.*;

class I {
    @Override
    public String toString() {
        return "I";
    }
}

class O {
    @Override
    public String toString() {
        return "O";
    }
}

/**
 * 泛型参数解释：
 * <V>：新返回函数的返回类型参数
 * T：原始函数的输入类型（当前函数）
 * R：原始函数的输出类型（当前函数）
 * ? super R：表示接受原始函数输出类型R或其父类型的函数
 * ? extends V：表示返回类型V或其子类型
 */

public class TransformFunction {

    /**
     *
     *  interface Function<T, R> {
     *      default <V> Function<T, V> andThen(Function<? super V, ? extends V> after) {
     *         Objects.requireNonNull(after);
     *         return (T t) -> after.apply(apply(t));
     *     }
     *     default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
     *         Objects.requireNonNull(after);
     *         return (T t) -> {
     *             // 当前对象(this)是 Function<T, R>
     *             // this.apply(t) 调用返回类型 R
     *             R intermediateResult = this.apply(t);
     *
     *             // after 是 Function<? super R, ? extends V>
     *             // after.apply() 将 R 转换为 V
     *             V finalResult = after.apply(intermediateResult);
     *
     *             return finalResult;
     *         };
     *     }
     * @param in
     * @return
     */

    static Function<I, O> transform(Function<I, O> in) {
        return in.andThen(o -> {// 0
            System.out.println("----after----" + o);
            return o;
        });
    }
    public static void main(String[] args) {
        Function<I, O> f2 = transform(i -> {
            System.out.println("----原始----" + i);
            return new O();
        });
        // 执行函数转换，传入新的I对象并获取返回的O对象
        O o = f2.apply(new I());
    }
}
